<!DOCTYPE html>
<html>
	<head>
		<meta charset="UTF-8">
		<title></title>
	</head>
	<body>
		<script type="text/javascript">
			//1.函数参数的默认值
			    //1.1 基本用法
			    	//ES6允许为函数的参数设置默认值，即直接写再参数定义的后面
//					          function log(x,y='World'){
//									console.log(x,y);
//							  }
//					          log('Hello');
                //1.2 与解构赋值默认值结合使用
//                        function foo({x,y=5}){
//                        	 //只使用了对象的解构赋值默认值
//							 console.log(x,5);
//						  }
//						  foo({x:1});
//                        foo();//报错

//                         function foo({x, y = 5} = {}) {
//                         	 //使用函数参数的默认值
//							  console.log(x, y);
//						   }
//						   foo();
                 //1.3 参数默认值的位置
                 //1.4 函数的 length 属性（指定了默认值以后，函数的length属性，将返回没有指定默认值的参数个数）
                 //1.5 作用域（一旦设置了参数的默认值，函数进行声明初始化时，参数会形成一个单独的作用域）
            
            //2.rest参数
                 //ES6 引入 rest 参数（形式为...变量名），用于获取函数的多余参数，这样就不需要使用arguments对象了。
                 //rest 参数搭配的变量是一个数组，该变量将多余的参数放入数组中。
//		                        function add(...values){
//									console.log(values);//[1,2,3,4,5]
//                                  console.log(values[0]);//1
//								}
//								add(1,2,3,4,5);
                 //arguments对象不是数组，而是一个类似数组的对象。所以为了使用数组的方法，必须使用Array.prototype.slice.call先将其转为数组。
                 //rest 参数就不存在这个问题，它就是一个真正的数组，数组特有的方法都可以使用。
//		                 		function push(){
//		                 			console.log(arguments.sort());//报错
//									console.log(Array.prototype.slice.call(arguments).sort());
//								}
//								push(1,5,6,2,4);//[1,2,4,5,6]
//								
//								const sortNumbers = (...numbers)=> console.log(numbers.sort());
//								sortNumbers(1,5,6,2,4);
                 //rest 参数之后不能再有其他参数（即只能是最后一个参数）
//                              function f(a,...b,c){
//	                                 
//								}//报错

            //3.严格模式
                //ES5 开始，函数内部可以设定为严格模式。
                //ES6 做了一点修改，规定只要函数参数使用了默认值、解构赋值、或者扩展运算符，那么函数内部就不能显式设定为严格模式
//                              function f(a,b=5){
//									'use strict';
//								}//默认值 报错
//								function f({a,b}){
//								   'use strict';
//								}//解构赋值 报错
//								function f(...values){
//								   'use strict';
//								}// 扩展运算符 报错
                 
                 //两种方法可以规避这种限制。第一种是设定全局性的严格模式，这是合法的。
                 //把函数包在一个无参数的立即执行函数里面。
                 
            //4.name属性
                //函数的name属性，返回该函数的函数名。
                //ES6 对这个属性的行为做出了一些修改。如果将一个匿名函数赋值给一个变量，ES5 的name属性，会返回空字符串
                //而 ES6 的name属性会返回实际的函数名。
                
			//5.箭头函数
			    //5.1 基本用法
			        //ES6 允许使用“箭头”（=>）定义函数。
//					         var f = v => v;
//						     var f = function (v) {
//						       return v;
//						     };
                    
                    //如果箭头函数不需要参数或需要多个参数，就使用一个圆括号代表参数部分。
//                           var sum = (a,b)=>a+b;
//					         console.log(sum(2,5));//7
//					         var sum = function(a,b){
//					               return a+b;
//					         }

                     //如果箭头函数的代码块部分多于一条语句，就要使用大括号将它们括起来，并且使用return语句返回
//                           var sum = ()=>{return num1 + num2}

                     //由于大括号被解释为代码块，所以如果箭头函数直接返回一个对象，必须在对象外面加上括号，否则会报错。
//                   		 let getTempItem = id => ({ id: id, name: "Temp" });
                     //箭头函数可以与变量解构结合使用
//                            const full = ({first,last})=>first+' '+last;
//							  console.log(full({first:'li',last:'shan'}));
                      //rest 参数与箭头函数结合的例子
//                            const numbers = (...nums)=>nums;
//							  numbers(1,2,3,4,5); 
                 //5.2 使用注意点
                       // 1.函数体内的this对象，就是定义时所在的对象，而不是使用时所在的对象
                       // 2.不可以当作构造函数，也就是说不可以使用new命令，否则会抛出一个错误
                       // 3.不可以使用arguments对象，该对象在函数体内不存在。如果要用，可以用rest参数代替
                       // 4.不可以使用yield命令，因此箭头函数不能用作Generator函数
	</script>
	</body>
</html>
